home *** CD-ROM | disk | FTP | other *** search
/ TeX 1995 July / TeX CD-ROM July 1995 (Disc 1)(Walnut Creek)(1995).ISO / graphics / gnuplot / util.c < prev    next >
C/C++ Source or Header  |  1993-09-15  |  13KB  |  624 lines
  1. #ifndef lint
  2. static char *RCSid = "$Id: util.c%v 3.50 1993/07/09 05:35:24 woo Exp $";
  3. #endif
  4.  
  5.  
  6. /* GNUPLOT - util.c */
  7. /*
  8.  * Copyright (C) 1986 - 1993   Thomas Williams, Colin Kelley
  9.  *
  10.  * Permission to use, copy, and distribute this software and its
  11.  * documentation for any purpose with or without fee is hereby granted, 
  12.  * provided that the above copyright notice appear in all copies and 
  13.  * that both that copyright notice and this permission notice appear 
  14.  * in supporting documentation.
  15.  *
  16.  * Permission to modify the software is granted, but not the right to
  17.  * distribute the modified code.  Modifications are to be distributed 
  18.  * as patches to released version.
  19.  *  
  20.  * This software is provided "as is" without express or implied warranty.
  21.  * 
  22.  *
  23.  * AUTHORS
  24.  * 
  25.  *   Original Software:
  26.  *     Thomas Williams,  Colin Kelley.
  27.  * 
  28.  *   Gnuplot 2.0 additions:
  29.  *       Russell Lang, Dave Kotz, John Campbell.
  30.  *
  31.  *   Gnuplot 3.0 additions:
  32.  *       Gershon Elber and many others.
  33.  * 
  34.  */
  35.  
  36. #include <ctype.h>
  37. #include <setjmp.h>
  38. #include <stdio.h>
  39. #include <errno.h>
  40. #include "plot.h"
  41.  
  42. TBOOLEAN screen_ok;
  43.     /* TRUE if command just typed; becomes FALSE whenever we
  44.         send some other output to screen.  If FALSE, the command line
  45.         will be echoed to the screen before the ^ error message. */
  46.  
  47. #ifndef vms
  48. #if !defined(__ZTC__) && !defined(__PUREC__)
  49. #if !defined(__MSC__)
  50. extern int errno;
  51. #endif
  52. extern int sys_nerr;
  53. extern char *sys_errlist[];
  54. #endif
  55. #endif /* vms */
  56.  
  57. extern char input_line[];
  58. extern struct lexical_unit token[];
  59. #ifdef _Windows
  60. extern jmp_buf far env;    /* from plot.c */
  61. #else
  62. extern jmp_buf env;    /* from plot.c */
  63. #endif
  64. extern int inline_num;        /* from command.c */
  65. extern TBOOLEAN interactive;    /* from plot.c */
  66. extern char *infile_name;    /* from plot.c */
  67.  
  68. #ifdef sequent
  69. extern char *index();
  70. #else
  71. extern char *strchr();
  72. #endif
  73.  
  74. #ifndef AMIGA_AC_5
  75. extern double sqrt(), atan2();
  76. #endif
  77.  
  78. /*
  79.  * chr_in_str() compares the characters in the string of token number t_num
  80.  * with c, and returns TRUE if a match was found.
  81.  */
  82. chr_in_str(t_num, c)
  83. int t_num;
  84. char c;
  85. {
  86. register int i;
  87.  
  88.     if (!token[t_num].is_token)
  89.         return(FALSE);                /* must be a value--can't be equal */
  90.     for (i = 0; i < token[t_num].length; i++) {
  91.         if (input_line[token[t_num].start_index+i] == c)
  92.             return(TRUE);
  93.         }
  94.     return FALSE;
  95. }
  96.  
  97.  
  98. /*
  99.  * equals() compares string value of token number t_num with str[], and
  100.  *   returns TRUE if they are identical.
  101.  */
  102. equals(t_num, str)
  103. int t_num;
  104. char *str;
  105. {
  106. register int i;
  107.  
  108.     if (!token[t_num].is_token)
  109.         return(FALSE);                /* must be a value--can't be equal */
  110.     for (i = 0; i < token[t_num].length; i++) {
  111.         if (input_line[token[t_num].start_index+i] != str[i])
  112.             return(FALSE);
  113.         }
  114.     /* now return TRUE if at end of str[], FALSE if not */
  115.     return(str[i] == '\0');
  116. }
  117.  
  118.  
  119.  
  120. /*
  121.  * almost_equals() compares string value of token number t_num with str[], and
  122.  *   returns TRUE if they are identical up to the first $ in str[].
  123.  */
  124. almost_equals(t_num, str)
  125. int t_num;
  126. char *str;
  127. {
  128. register int i;
  129. register int after = 0;
  130. register start = token[t_num].start_index;
  131. register length = token[t_num].length;
  132.  
  133.     if (!token[t_num].is_token)
  134.         return(FALSE);                /* must be a value--can't be equal */
  135.     for (i = 0; i < length + after; i++) {
  136.         if (str[i] != input_line[start + i]) {
  137.             if (str[i] != '$')
  138.                 return(FALSE);
  139.             else {
  140.                 after = 1;
  141.                 start--;    /* back up token ptr */
  142.                 }
  143.             }
  144.         }
  145.  
  146.     /* i now beyond end of token string */
  147.  
  148.     return(after || str[i] == '$' || str[i] == '\0');
  149. }
  150.  
  151.  
  152.  
  153. isstring(t_num)
  154. int t_num;
  155. {
  156.     
  157.     return(token[t_num].is_token &&
  158.            (input_line[token[t_num].start_index] == '\'' ||
  159.            input_line[token[t_num].start_index] == '\"'));
  160. }
  161.  
  162.  
  163. isnumber(t_num)
  164. int t_num;
  165. {
  166.     return(!token[t_num].is_token);
  167. }
  168.  
  169.  
  170. isletter(t_num)
  171. int t_num;
  172. {
  173.     return(token[t_num].is_token &&
  174.             ((isalpha(input_line[token[t_num].start_index]))||
  175.              (input_line[token[t_num].start_index] == '_')));
  176. }
  177.  
  178.  
  179. /*
  180.  * is_definition() returns TRUE if the next tokens are of the form
  181.  *   identifier =
  182.  *        -or-
  183.  *   identifier ( identifer {,identifier} ) =
  184.  */
  185. is_definition(t_num)
  186. int t_num;
  187. {
  188.     /* variable? */
  189.     if(isletter(t_num) && equals(t_num+1,"="))
  190.         return 1;
  191.  
  192.     /* function? */
  193.     /* look for dummy variables */
  194.     if(isletter(t_num) && equals(t_num+1,"(") && isletter(t_num+2)) {
  195.         t_num += 3;  /* point past first dummy */
  196.         while(equals(t_num,",")) {
  197.             if(!isletter(++t_num))
  198.                 return 0;
  199.             t_num += 1;
  200.         }
  201.         return(equals(t_num,")") && equals(t_num+1,"="));
  202.     }
  203.  
  204.     /* neither */
  205.     return 0;
  206. }
  207.  
  208.  
  209.  
  210. /*
  211.  * copy_str() copies the string in token number t_num into str, appending
  212.  *   a null.  No more than MAX_ID_LEN chars are copied.
  213.  */
  214. copy_str(str, t_num)
  215. char str[];
  216. int t_num;
  217. {
  218. register int i = 0;
  219. register int start = token[t_num].start_index;
  220. register int count;
  221.  
  222.     if ((count = token[t_num].length) > MAX_ID_LEN)
  223.         count = MAX_ID_LEN;
  224.     do {
  225.         str[i++] = input_line[start++];
  226.         } while (i != count);
  227.     str[i] = '\0';
  228. }
  229.  
  230.  
  231. /*
  232.  * quote_str() does the same thing as copy_str, except it ignores the
  233.  *   quotes at both ends.  This seems redundant, but is done for
  234.  *   efficency.
  235.  */
  236. quote_str(str, t_num)
  237. char str[];
  238. int t_num;
  239. {
  240. register int i = 0;
  241. register int start = token[t_num].start_index + 1;
  242. register int count;
  243.  
  244.     if ((count = token[t_num].length - 2) > MAX_ID_LEN)
  245.         count = MAX_ID_LEN;
  246.     if (count>0) {
  247.         do {
  248.             str[i++] = input_line[start++];
  249.             } while (i != count);
  250.     }
  251.     str[i] = '\0';
  252. }
  253.  
  254.  
  255. /*
  256.  * quotel_str() does the same thing as quote_str, except it uses
  257.  * MAX_LINE_LEN instead of MAX_ID_LEN. 
  258.  */ 
  259. quotel_str(str, t_num) 
  260. char str[]; 
  261. int t_num; 
  262. {
  263. register int i = 0;
  264. register int start = token[t_num].start_index + 1;
  265. register int count;
  266.  
  267.     if ((count = token[t_num].length - 2) > MAX_LINE_LEN)
  268.         count = MAX_LINE_LEN;
  269.     if (count>0) {
  270.         do {
  271.             str[i++] = input_line[start++];
  272.             } while (i != count);
  273.     }
  274.     str[i] = '\0';
  275. }
  276.  
  277.  
  278. /*
  279.  *    capture() copies into str[] the part of input_line[] which lies between
  280.  *    the begining of token[start] and end of token[end].
  281.  */
  282. capture(str,start,end)
  283. char str[];
  284. int start,end;
  285. {
  286. register int i,e;
  287.  
  288.     e = token[end].start_index + token[end].length;
  289.     for (i = token[start].start_index; i < e && input_line[i] != '\0'; i++)
  290.         *str++ = input_line[i];
  291.     *str = '\0';
  292. }
  293.  
  294.  
  295. /*
  296.  *    m_capture() is similar to capture(), but it mallocs storage for the
  297.  *  string.
  298.  */
  299. m_capture(str,start,end)
  300. char **str;
  301. int start,end;
  302. {
  303. register int i,e;
  304. register char *s;
  305.  
  306.     if (*str)        /* previous pointer to malloc'd memory there */
  307.         free(*str);
  308.     e = token[end].start_index + token[end].length;
  309.     *str = alloc((unsigned long)(e - token[start].start_index + 1), "string");
  310.      s = *str;
  311.      for (i = token[start].start_index; i < e && input_line[i] != '\0'; i++)
  312.       *s++ = input_line[i];
  313.      *s = '\0';
  314. }
  315.  
  316.  
  317. /*
  318.  *    m_quote_capture() is similar to m_capture(), but it removes
  319.     quotes from either end if the string.
  320.  */
  321. m_quote_capture(str,start,end)
  322. char **str;
  323. int start,end;
  324. {
  325. register int i,e;
  326. register char *s;
  327.  
  328.     if (*str)        /* previous pointer to malloc'd memory there */
  329.         free(*str);
  330.     e = token[end].start_index + token[end].length-1;
  331.     *str = alloc((unsigned long)(e - token[start].start_index + 1), "string");
  332.      s = *str;
  333.     for (i = token[start].start_index + 1; i < e && input_line[i] != '\0'; i++)
  334.      *s++ = input_line[i];
  335.     *s = '\0';
  336. }
  337.  
  338.  
  339. convert(val_ptr, t_num)
  340. struct value *val_ptr;
  341. int t_num;
  342. {
  343.     *val_ptr = token[t_num].l_val;
  344. }
  345.  
  346. static char *num_to_str(r)
  347. double r;
  348. {
  349.     static i = 0;
  350.     static char s[4][20];
  351.     int j = i++;
  352.  
  353.     if ( i > 3 ) i = 0;
  354.  
  355.     sprintf( s[j], "%g", r );
  356. #ifdef sequent
  357.     if ( index( s[j], '.' ) == NULL &&
  358.          index( s[j], 'e' ) == NULL &&
  359.          index( s[j], 'E' ) == NULL )
  360. #else
  361.     if ( strchr( s[j], '.' ) == NULL &&
  362.          strchr( s[j], 'e' ) == NULL &&
  363.          strchr( s[j], 'E' ) == NULL )
  364. #endif
  365.         strcat( s[j], ".0" );
  366.  
  367.     return s[j];
  368. } 
  369.  
  370. disp_value(fp,val)
  371. FILE *fp;
  372. struct value *val;
  373. {
  374.     switch(val->type) {
  375.         case INTGR:
  376.             fprintf(fp,"%d",val->v.int_val);
  377.             break;
  378.         case CMPLX:
  379.             if (val->v.cmplx_val.imag != 0.0 )
  380.                 fprintf(fp,"{%s, %s}",
  381.                     num_to_str(val->v.cmplx_val.real),
  382.                     num_to_str(val->v.cmplx_val.imag));
  383.             else
  384.                 fprintf(fp,"%s",
  385.                     num_to_str(val->v.cmplx_val.real));
  386.             break;
  387.         default:
  388.             int_error("unknown type in disp_value()",NO_CARET);
  389.     }
  390. }
  391.  
  392.  
  393. double
  394. real(val)        /* returns the real part of val */
  395. struct value *val;
  396. {
  397.     switch(val->type) {
  398.         case INTGR:
  399.             return((double) val->v.int_val);
  400.         case CMPLX:
  401.             return(val->v.cmplx_val.real);
  402.     }
  403.     int_error("unknown type in real()",NO_CARET);
  404.     /* NOTREACHED */
  405.     return((double)0.0);
  406. }
  407.  
  408.  
  409. double
  410. imag(val)        /* returns the imag part of val */
  411. struct value *val;
  412. {
  413.     switch(val->type) {
  414.         case INTGR:
  415.             return(0.0);
  416.         case CMPLX:
  417.             return(val->v.cmplx_val.imag);
  418.     }
  419.     int_error("unknown type in imag()",NO_CARET);
  420.     /* NOTREACHED */
  421.     return((double)0.0);
  422. }
  423.  
  424.  
  425.  
  426. double
  427. magnitude(val)        /* returns the magnitude of val */
  428. struct value *val;
  429. {
  430.     switch(val->type) {
  431.         case INTGR:
  432.             return((double) abs(val->v.int_val));
  433.         case CMPLX:
  434.             return(sqrt(val->v.cmplx_val.real*
  435.                     val->v.cmplx_val.real +
  436.                     val->v.cmplx_val.imag*
  437.                     val->v.cmplx_val.imag));
  438.     }
  439.     int_error("unknown type in magnitude()",NO_CARET);
  440.     /* NOTREACHED */
  441.     return((double)0.0);
  442. }
  443.  
  444.  
  445.  
  446. double
  447. angle(val)        /* returns the angle of val */
  448. struct value *val;
  449. {
  450.     switch(val->type) {
  451.         case INTGR:
  452.             return((val->v.int_val > 0) ? 0.0 : Pi);
  453.         case CMPLX:
  454.             if (val->v.cmplx_val.imag == 0.0) {
  455.                 if (val->v.cmplx_val.real >= 0.0)
  456.                     return(0.0);
  457.                 else
  458.                     return(Pi);
  459.             }
  460.             return(atan2(val->v.cmplx_val.imag,
  461.                      val->v.cmplx_val.real));
  462.     }
  463.     int_error("unknown type in angle()",NO_CARET);
  464.     /* NOTREACHED */
  465.     return((double)0.0);
  466. }
  467.  
  468.  
  469. struct value *
  470. Gcomplex(a,realpart,imagpart)
  471. struct value *a;
  472. double realpart, imagpart;
  473. {
  474.     a->type = CMPLX;
  475.     a->v.cmplx_val.real = realpart;
  476.     a->v.cmplx_val.imag = imagpart;
  477.     return(a);
  478. }
  479.  
  480.  
  481. struct value *
  482. Ginteger(a,i)
  483. struct value *a;
  484. int i;
  485. {
  486.     a->type = INTGR;
  487.     a->v.int_val = i;
  488.     return(a);
  489. }
  490.  
  491.  
  492.  
  493. os_error(str,t_num)
  494. char str[];
  495. int t_num;
  496. {
  497. #ifdef vms
  498. static status[2] = {1, 0};        /* 1 is count of error msgs */
  499. #endif
  500.  
  501. register int i;
  502.  
  503.     /* reprint line if screen has been written to */
  504.  
  505.     if (t_num != NO_CARET) {        /* put caret under error */
  506.         if (!screen_ok)
  507.             fprintf(stderr,"\n%s%s\n", PROMPT, input_line);
  508.  
  509.         for (i = 0; i < sizeof(PROMPT) - 1; i++)
  510.             (void) putc(' ',stderr);
  511.         for (i = 0; i < token[t_num].start_index; i++) {
  512.             (void) putc((input_line[i] == '\t') ? '\t' : ' ',stderr);
  513.             }
  514.         (void) putc('^',stderr);
  515.         (void) putc('\n',stderr);
  516.     }
  517.  
  518.     for (i = 0; i < sizeof(PROMPT) - 1; i++)
  519.         (void) putc(' ',stderr);
  520.     fprintf(stderr,"%s\n",str);
  521.  
  522.     for (i = 0; i < sizeof(PROMPT) - 1; i++)
  523.         (void) putc(' ',stderr);
  524.      if (!interactive)
  525.       if (infile_name != NULL)
  526.         fprintf(stderr,"\"%s\", line %d: ", infile_name, inline_num);
  527.       else
  528.         fprintf(stderr,"line %d: ", inline_num);
  529.  
  530.  
  531. #ifdef vms
  532.     status[1] = vaxc$errno;
  533.     sys$putmsg(status);
  534.     (void) putc('\n',stderr);
  535. #else
  536. #ifdef __ZTC__
  537.     fprintf(stderr,"error number %d\n\n",errno);
  538. #else
  539.     if (errno >= sys_nerr)
  540.         fprintf(stderr, "unknown errno %d\n\n", errno);
  541.     else
  542.         fprintf(stderr,"(%s)\n\n",sys_errlist[errno]);
  543. #endif
  544. #endif
  545.  
  546.     longjmp(env, TRUE);    /* bail out to command line */
  547. }
  548.  
  549.  
  550. int_error(str,t_num)
  551. char str[];
  552. int t_num;
  553. {
  554. register int i;
  555.  
  556.     /* reprint line if screen has been written to */
  557.  
  558.     if (t_num != NO_CARET) {        /* put caret under error */
  559.         if (!screen_ok)
  560.             fprintf(stderr,"\n%s%s\n", PROMPT, input_line);
  561.  
  562.         for (i = 0; i < sizeof(PROMPT) - 1; i++)
  563.             (void) putc(' ',stderr);
  564.         for (i = 0; i < token[t_num].start_index; i++) {
  565.             (void) putc((input_line[i] == '\t') ? '\t' : ' ',stderr);
  566.             }
  567.         (void) putc('^',stderr);
  568.         (void) putc('\n',stderr);
  569.     }
  570.  
  571.     for (i = 0; i < sizeof(PROMPT) - 1; i++)
  572.         (void) putc(' ',stderr);
  573.      if (!interactive)
  574.       if (infile_name != NULL)
  575.         fprintf(stderr,"\"%s\", line %d: ", infile_name, inline_num);
  576.       else
  577.         fprintf(stderr,"line %d: ", inline_num);
  578.      fprintf(stderr,"%s\n\n", str);
  579.  
  580.     longjmp(env, TRUE);    /* bail out to command line */
  581. }
  582.  
  583. /* Lower-case the given string (DFK) */
  584. /* Done in place. */
  585. void
  586. lower_case(s)
  587.      char *s;
  588. {
  589.   register char *p = s;
  590.  
  591.   while (*p != '\0') {
  592.     if (isupper(*p))
  593.      *p = tolower(*p);
  594.     p++;
  595.   }
  596. }
  597.  
  598. /* Squash spaces in the given string (DFK) */
  599. /* That is, reduce all multiple white-space chars to single spaces */
  600. /* Done in place. */
  601. void
  602. squash_spaces(s)
  603.      char *s;
  604. {
  605.   register char *r = s;        /* reading point */
  606.   register char *w = s;        /* writing point */
  607.   TBOOLEAN space = FALSE;        /* TRUE if we've already copied a space */
  608.  
  609.   for (w = r = s; *r != '\0'; r++) {
  610.      if (isspace(*r)) {
  611.         /* white space; only copy if we haven't just copied a space */
  612.         if (!space) {
  613.             space = TRUE;
  614.             *w++ = ' ';
  615.         }                /* else ignore multiple spaces */
  616.      } else {
  617.         /* non-space character; copy it and clear flag */
  618.         *w++ = *r;
  619.         space = FALSE;
  620.      }
  621.   }
  622.   *w = '\0';                /* null terminate string */
  623. }
  624.